/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package modelo;


import java.util.* ;
import java.math.*;
/**
 *
 * @author lidier
 */
public class algoritmos {
       
//********************************************************************************************************************
//********************************************************************************************************************
   public List algoritmo_sjf(List procesos)
    {
        comparar_por_td c = new comparar_por_td();
        Collections.sort(procesos, c);
        procesos = ordenar_sjf(procesos);
        return procesos;
    }

public class comparar_por_td implements Comparator<Object>
    {
        public int compare(Object o1, Object o2) {
            int ret = 0;
            if ((o1 instanceof proceso) && (o2 instanceof proceso))
            {
                proceso p1 = (proceso) o1;
                proceso p2 = (proceso) o2;

                if (p1.td < p2.td)
                {
                    ret = -1;
                }
                else
                    if (p1.td > p2.td)
                    {
                        ret = 1;
                    }
                    else
                        ret = 0;
            }
            return ret;
        }
    }

public List ordenar_sjf(List l) {
        int tmp = 0;
        int pos = 0;
        List lista_sjf = new java.util.ArrayList<proceso>();

        while (!l.isEmpty()){

        proceso p = (proceso) l.get(pos);

         if (p.tl > tmp)
         {
             if (pos < l.size()-1)
                pos++;
             else
                 pos = 0;
         }
         else
         {
            lista_sjf.add(p);
            l.remove(p);
            tmp += p.td;
            pos = 0;
         }}
        return lista_sjf;
    }
//********************************************************************************************************************
//********************************************************************************************************************
    
    public List algoritmo_rr(List procesos, int quantum)
    {
        float tiempo = 0;
        List lista_resultado = new java.util.ArrayList<proceso>();
        List lista_llegadas = new java.util.ArrayList<proceso>();
        procesos = algoritmo_fcfs(procesos);
        proceso p = null;
        if (!procesos.isEmpty())
        {
            p = (proceso) procesos.get(0);
            tiempo = p.tl;
        }
        
        while (!procesos.isEmpty()||(!lista_llegadas.isEmpty()))
        {
            //Buscamos los procesos nuevos que han llegado para agregarlos a la lista
            if (!procesos.isEmpty())
            {
                p = (proceso) procesos.get(0);
                while ((p.tl <= tiempo)&&(!procesos.isEmpty()))
                {
                    lista_llegadas.add(p);
                    procesos.remove(0);
                    if (!procesos.isEmpty())
                        p = (proceso) procesos.get(0);
                }
            }
            //Si no hay procesos que puedan ser ejecutados en este momento
            //Se debe agregar el primero de la lista y ajustar la variable tiempo
            if (lista_llegadas.isEmpty())
            {
                p = (proceso) procesos.get(0);
                lista_llegadas.add(p);
                procesos.remove(0);
                tiempo = p.tl;
            }
            //Los procesos que han llegado estan en la lista_llegadas y de deben rotar
            p = (proceso)lista_llegadas.get(0);
            if (p.td <= quantum)
            {
                lista_resultado.add(p);
                lista_llegadas.remove(0);
                tiempo += p.td;
            }
            else
            {
                proceso ptemp = new proceso(p.nom,p.pid,quantum,p.tl);
                lista_resultado.add(ptemp);
                
                tiempo += quantum;
                p.td -= quantum;
                p.tl = tiempo;
                
                if (lista_llegadas.size()>1)
                {
                    lista_llegadas.add(lista_llegadas.get(0));
                    lista_llegadas.remove(0);
                }
            }
        }
        return lista_resultado;
    }
    public static int redondear_hacia_arriba_siempre(float f)
    {
        if (Math.round(f) == f )
            return Math.round(f);
        else
            return ((int) f) +1;
    }
    
//********************************************************************************************************************
//********************************************************************************************************************
    
    public List algoritmo_fcfs(List procesos)
    {
        comparar_por_tl c = new comparar_por_tl();
        Collections.sort(procesos, c);
        return procesos;
    }
    
    public class comparar_por_tl implements Comparator<Object> 
    {
        public int compare(Object o1, Object o2) {
            int ret = 0;
            if ((o1 instanceof proceso) && (o2 instanceof proceso))
            {
                proceso p1 = (proceso) o1;
                proceso p2 = (proceso) o2;
                
                if (p1.tl < p2.tl)
                {
                    ret = -1;
                }
                else 
                    if (p1.tl > p2.tl)
                    {
                        ret = 1;
                    }
                    else 
                        ret = 0;
            }
            return ret;
        }
    }
    
    
}
